//! Bindings to JavaScript's standard, built-in objects, including their methods

//! and properties.

//!

//! This does *not* include any Web, Node, or any other JS environment

//! APIs. Only the things that are guaranteed to exist in the global scope by

//! the ECMAScript standard.

//!

//! <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects>

//!

//! ## A Note About `camelCase`, `snake_case`, and Naming Conventions

//!

//! JavaScript's global objects use `camelCase` naming conventions for functions

//! and methods, but Rust style is to use `snake_case`. These bindings expose

//! the Rust style `snake_case` name. Additionally, acronyms within a method

//! name are all lower case, where as in JavaScript they are all upper case. For

//! example, `decodeURI` in JavaScript is exposed as `decode_uri` in these

//! bindings.

#![doc(html_root_url = "https://docs.rs/js-sys/0.2")]

use core::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Not, Rem, Shl, Shr, Sub};

use std::cmp::Ordering;

use std::convert::{self, Infallible, TryFrom};

use std::f64;

use std::fmt;

use std::iter::{self, Product, Sum};

use std::mem;

use std::str;

use std::str::FromStr;

pub use wasm_bindgen;

use wasm_bindgen::prelude::*;

// When adding new imports:

//

// * Keep imports in alphabetical order.

//

// * Rename imports with `js_name = ...` according to the note about `camelCase`

//   and `snake_case` in the module's documentation above.

//

// * Include the one sentence summary of the import from the MDN link in the

//   module's documentation above, and the MDN link itself.

//

// * If a function or method can throw an exception, make it catchable by adding

//   `#[wasm_bindgen(catch)]`.

//

// * Add a new `#[test]` into the appropriate file in the

//   `crates/js-sys/tests/wasm/` directory. If the imported function or method

//   can throw an exception, make sure to also add test coverage for that case.

//

// * Arguments that are `JsValue`s or imported JavaScript types should be taken

//   by reference.

macro_rules! forward_deref_unop {

    (impl $imp:ident, $method:ident for $t:ty) => {

        impl $imp for $t {

            type Output = <&'static $t as $imp>::Output;

            #[inline]

        }

    };

}

macro_rules! forward_deref_binop {

    (impl $imp:ident, $method:ident for $t:ty) => {

        impl<'a> $imp<$t> for &'a $t {

            type Output = <&'static $t as $imp<&'static $t>>::Output;

            #[inline]

        }

        impl $imp<&$t> for $t {

            type Output = <&'static $t as $imp<&'static $t>>::Output;

            #[inline]

        }

        impl $imp<$t> for $t {

            type Output = <&'static $t as $imp<&'static $t>>::Output;

            #[inline]

        }

    };

}

macro_rules! forward_js_unop {

    (impl $imp:ident, $method:ident for $t:ty) => {

        impl $imp for &$t {

            type Output = $t;

            #[inline]

        }

        forward_deref_unop!(impl $imp, $method for $t);

    };

}

macro_rules! forward_js_binop {

    (impl $imp:ident, $method:ident for $t:ty) => {

        impl $imp<&$t> for &$t {

            type Output = $t;

            #[inline]

        }

        forward_deref_binop!(impl $imp, $method for $t);

    };

}

macro_rules! sum_product {

    ($($a:ident)*) => ($(

        impl Sum for $a {

            #[inline]

        }

        impl Product for $a {

            #[inline]

        }

        impl<'a> Sum<&'a $a> for $a {

        }

        impl<'a> Product<&'a $a> for $a {

            #[inline]

        }

    )*)

}

macro_rules! partialord_ord {

    ($t:ident) => {

        impl PartialOrd for $t {

            #[inline]

            #[inline]

            #[inline]

            #[inline]

            #[inline]

        }

        impl Ord for $t {

            #[inline]

                } else {

                }

        }

    };

}

extern "C" {

    /// The `decodeURI()` function decodes a Uniform Resource Identifier (URI)

    /// previously created by `encodeURI` or by a similar routine.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURI)

    #[wasm_bindgen(catch, js_name = decodeURI)]

    pub fn decode_uri(encoded: &str) -> Result<JsString, JsValue>;

    /// The `decodeURIComponent()` function decodes a Uniform Resource Identifier (URI) component

    /// previously created by `encodeURIComponent` or by a similar routine.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent)

    #[wasm_bindgen(catch, js_name = decodeURIComponent)]

    pub fn decode_uri_component(encoded: &str) -> Result<JsString, JsValue>;

    /// The `encodeURI()` function encodes a Uniform Resource Identifier (URI)

    /// by replacing each instance of certain characters by one, two, three, or

    /// four escape sequences representing the UTF-8 encoding of the character

    /// (will only be four escape sequences for characters composed of two

    /// "surrogate" characters).

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURI)

    #[wasm_bindgen(js_name = encodeURI)]

    pub fn encode_uri(decoded: &str) -> JsString;

    /// The `encodeURIComponent()` function encodes a Uniform Resource Identifier (URI) component

    /// by replacing each instance of certain characters by one, two, three, or four escape sequences

    /// representing the UTF-8 encoding of the character

    /// (will only be four escape sequences for characters composed of two "surrogate" characters).

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent)

    #[wasm_bindgen(js_name = encodeURIComponent)]

    pub fn encode_uri_component(decoded: &str) -> JsString;

    /// The `eval()` function evaluates JavaScript code represented as a string.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval)

    #[wasm_bindgen(catch)]

    pub fn eval(js_source_text: &str) -> Result<JsValue, JsValue>;

    /// The global `isFinite()` function determines whether the passed value is a finite number.

    /// If needed, the parameter is first converted to a number.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite)

    #[wasm_bindgen(js_name = isFinite)]

    pub fn is_finite(value: &JsValue) -> bool;

    /// The `parseInt()` function parses a string argument and returns an integer

    /// of the specified radix (the base in mathematical numeral systems), or NaN on error.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt)

    #[wasm_bindgen(js_name = parseInt)]

    pub fn parse_int(text: &str, radix: u8) -> f64;

    /// The `parseFloat()` function parses an argument and returns a floating point number,

    /// or NaN on error.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseFloat)

    #[wasm_bindgen(js_name = parseFloat)]

    pub fn parse_float(text: &str) -> f64;

    /// The `escape()` function computes a new string in which certain characters have been

    /// replaced by a hexadecimal escape sequence.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/escape)

    #[wasm_bindgen]

    pub fn escape(string: &str) -> JsString;

    /// The `unescape()` function computes a new string in which hexadecimal escape

    /// sequences are replaced with the character that it represents. The escape sequences might

    /// be introduced by a function like `escape`. Usually, `decodeURI` or `decodeURIComponent`

    /// are preferred over `unescape`.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/unescape)

    #[wasm_bindgen]

    pub fn unescape(string: &str) -> JsString;

}

// Array

extern "C" {

    #[wasm_bindgen(extends = Object, is_type_of = Array::is_array, typescript_type = "Array<any>")]

    #[derive(Clone, Debug, PartialEq, Eq)]

    pub type Array;

    /// Creates a new empty array.

    #[wasm_bindgen(constructor)]

    pub fn new() -> Array;

    /// Creates a new array with the specified length (elements are initialized to `undefined`).

    #[wasm_bindgen(constructor)]

    pub fn new_with_length(len: u32) -> Array;

    /// Retrieves the element at the index, counting from the end if negative

    /// (returns `undefined` if the index is out of range).

    #[wasm_bindgen(method)]

    pub fn at(this: &Array, index: i32) -> JsValue;

    /// Retrieves the element at the index (returns `undefined` if the index is out of range).

    #[wasm_bindgen(method, structural, indexing_getter)]

    pub fn get(this: &Array, index: u32) -> JsValue;

    /// Sets the element at the index (auto-enlarges the array if the index is out of range).

    #[wasm_bindgen(method, structural, indexing_setter)]

    pub fn set(this: &Array, index: u32, value: JsValue);

    /// Deletes the element at the index (does nothing if the index is out of range).

    ///

    /// The element at the index is set to `undefined`.

    ///

    /// This does not resize the array, the array will still be the same length.

    #[wasm_bindgen(method, structural, indexing_deleter)]

    pub fn delete(this: &Array, index: u32);

    /// The `Array.from()` method creates a new, shallow-copied `Array` instance

    /// from an array-like or iterable object.

    #[wasm_bindgen(static_method_of = Array)]

    pub fn from(val: &JsValue) -> Array;

    /// The `copyWithin()` method shallow copies part of an array to another

    /// location in the same array and returns it, without modifying its size.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin)

    #[wasm_bindgen(method, js_name = copyWithin)]

    pub fn copy_within(this: &Array, target: i32, start: i32, end: i32) -> Array;

    /// The `concat()` method is used to merge two or more arrays. This method

    /// does not change the existing arrays, but instead returns a new array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat)

    #[wasm_bindgen(method)]

    pub fn concat(this: &Array, array: &Array) -> Array;

    /// The `every()` method tests whether all elements in the array pass the test

    /// implemented by the provided function.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every)

    #[wasm_bindgen(method)]

    pub fn every(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> bool) -> bool;

    /// The `fill()` method fills all the elements of an array from a start index

    /// to an end index with a static value. The end index is not included.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill)

    #[wasm_bindgen(method)]

    pub fn fill(this: &Array, value: &JsValue, start: u32, end: u32) -> Array;

    /// The `filter()` method creates a new array with all elements that pass the

    /// test implemented by the provided function.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)

    #[wasm_bindgen(method)]

    pub fn filter(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> bool) -> Array;

    /// The `find()` method returns the value of the first element in the array that satisfies

    ///  the provided testing function. Otherwise `undefined` is returned.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)

    #[wasm_bindgen(method)]

    pub fn find(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> bool) -> JsValue;

    /// The `findIndex()` method returns the index of the first element in the array that

    /// satisfies the provided testing function. Otherwise -1 is returned.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex)

    #[wasm_bindgen(method, js_name = findIndex)]

    pub fn find_index(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> bool) -> i32;

    /// The `flat()` method creates a new array with all sub-array elements concatenated into it

    /// recursively up to the specified depth.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat)

    #[wasm_bindgen(method)]

    pub fn flat(this: &Array, depth: i32) -> Array;

    /// The `flatMap()` method first maps each element using a mapping function, then flattens

    /// the result into a new array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap)

    #[wasm_bindgen(method, js_name = flatMap)]

    pub fn flat_map(

        this: &Array,

        callback: &mut dyn FnMut(JsValue, u32, Array) -> Vec<JsValue>,

    ) -> Array;

    /// The `forEach()` method executes a provided function once for each array element.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)

    #[wasm_bindgen(method, js_name = forEach)]

    pub fn for_each(this: &Array, callback: &mut dyn FnMut(JsValue, u32, Array));

    /// The `includes()` method determines whether an array includes a certain

    /// element, returning true or false as appropriate.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes)

    #[wasm_bindgen(method)]

    pub fn includes(this: &Array, value: &JsValue, from_index: i32) -> bool;

    /// The `indexOf()` method returns the first index at which a given element

    /// can be found in the array, or -1 if it is not present.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)

    #[wasm_bindgen(method, js_name = indexOf)]

    pub fn index_of(this: &Array, value: &JsValue, from_index: i32) -> i32;

    /// The `Array.isArray()` method determines whether the passed value is an Array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)

    #[wasm_bindgen(static_method_of = Array, js_name = isArray)]

    pub fn is_array(value: &JsValue) -> bool;

    /// The `join()` method joins all elements of an array (or an array-like object)

    /// into a string and returns this string.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join)

    #[wasm_bindgen(method)]

    pub fn join(this: &Array, delimiter: &str) -> JsString;

    /// The `lastIndexOf()` method returns the last index at which a given element

    /// can be found in the array, or -1 if it is not present. The array is

    /// searched backwards, starting at fromIndex.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf)

    #[wasm_bindgen(method, js_name = lastIndexOf)]

    pub fn last_index_of(this: &Array, value: &JsValue, from_index: i32) -> i32;

    /// The length property of an object which is an instance of type Array

    /// sets or returns the number of elements in that array. The value is an

    /// unsigned, 32-bit integer that is always numerically greater than the

    /// highest index in the array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length)

    #[wasm_bindgen(method, getter, structural)]

    pub fn length(this: &Array) -> u32;

    /// Sets the length of the array.

    ///

    /// If it is set to less than the current length of the array, it will

    /// shrink the array.

    ///

    /// If it is set to more than the current length of the array, it will

    /// increase the length of the array, filling the new space with empty

    /// slots.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length)

    #[wasm_bindgen(method, setter)]

    pub fn set_length(this: &Array, value: u32);

    /// `map()` calls a provided callback function once for each element in an array,

    /// in order, and constructs a new array from the results. callback is invoked

    /// only for indexes of the array which have assigned values, including undefined.

    /// It is not called for missing elements of the array (that is, indexes that have

    /// never been set, which have been deleted or which have never been assigned a value).

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)

    #[wasm_bindgen(method)]

    pub fn map(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> JsValue) -> Array;

    /// The `Array.of()` method creates a new Array instance with a variable

    /// number of arguments, regardless of number or type of the arguments.

    ///

    /// The difference between `Array.of()` and the `Array` constructor is in the

    /// handling of integer arguments: `Array.of(7)` creates an array with a single

    /// element, `7`, whereas `Array(7)` creates an empty array with a `length`

    /// property of `7` (Note: this implies an array of 7 empty slots, not slots

    /// with actual undefined values).

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)

    ///

    /// # Notes

    ///

    /// There are a few bindings to `of` in `js-sys`: `of1`, `of2`, etc...

    /// with different arities.

    #[wasm_bindgen(static_method_of = Array, js_name = of)]

    pub fn of1(a: &JsValue) -> Array;

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)

    #[wasm_bindgen(static_method_of = Array, js_name = of)]

    pub fn of2(a: &JsValue, b: &JsValue) -> Array;

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)

    #[wasm_bindgen(static_method_of = Array, js_name = of)]

    pub fn of3(a: &JsValue, b: &JsValue, c: &JsValue) -> Array;

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)

    #[wasm_bindgen(static_method_of = Array, js_name = of)]

    pub fn of4(a: &JsValue, b: &JsValue, c: &JsValue, d: &JsValue) -> Array;

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)

    #[wasm_bindgen(static_method_of = Array, js_name = of)]

    pub fn of5(a: &JsValue, b: &JsValue, c: &JsValue, d: &JsValue, e: &JsValue) -> Array;

    /// The `pop()` method removes the last element from an array and returns that

    /// element. This method changes the length of the array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop)

    #[wasm_bindgen(method)]

    pub fn pop(this: &Array) -> JsValue;

    /// The `push()` method adds one or more elements to the end of an array and

    /// returns the new length of the array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)

    #[wasm_bindgen(method)]

    pub fn push(this: &Array, value: &JsValue) -> u32;

    /// The `reduce()` method applies a function against an accumulator and each element in

    /// the array (from left to right) to reduce it to a single value.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce)

    #[wasm_bindgen(method)]

    pub fn reduce(

        this: &Array,

        predicate: &mut dyn FnMut(JsValue, JsValue, u32, Array) -> JsValue,

        initial_value: &JsValue,

    ) -> JsValue;

    /// The `reduceRight()` method applies a function against an accumulator and each value

    /// of the array (from right-to-left) to reduce it to a single value.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight)

    #[wasm_bindgen(method, js_name = reduceRight)]

    pub fn reduce_right(

        this: &Array,

        predicate: &mut dyn FnMut(JsValue, JsValue, u32, Array) -> JsValue,

        initial_value: &JsValue,

    ) -> JsValue;

    /// The `reverse()` method reverses an array in place. The first array

    /// element becomes the last, and the last array element becomes the first.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)

    #[wasm_bindgen(method)]

    pub fn reverse(this: &Array) -> Array;

    /// The `shift()` method removes the first element from an array and returns

    /// that removed element. This method changes the length of the array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift)

    #[wasm_bindgen(method)]

    pub fn shift(this: &Array) -> JsValue;

    /// The `slice()` method returns a shallow copy of a portion of an array into

    /// a new array object selected from begin to end (end not included).

    /// The original array will not be modified.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)

    #[wasm_bindgen(method)]

    pub fn slice(this: &Array, start: u32, end: u32) -> Array;

    /// The `some()` method tests whether at least one element in the array passes the test implemented

    /// by the provided function.

    /// Note: This method returns false for any condition put on an empty array.

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)

    #[wasm_bindgen(method)]

    pub fn some(this: &Array, predicate: &mut dyn FnMut(JsValue) -> bool) -> bool;

    /// The `sort()` method sorts the elements of an array in place and returns

    /// the array. The sort is not necessarily stable. The default sort

    /// order is according to string Unicode code points.

    ///

    /// The time and space complexity of the sort cannot be guaranteed as it

    /// is implementation dependent.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)

    #[wasm_bindgen(method)]

    pub fn sort(this: &Array) -> Array;

    /// The `splice()` method changes the contents of an array by removing existing elements and/or

    /// adding new elements.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)

    #[wasm_bindgen(method)]

    pub fn splice(this: &Array, start: u32, delete_count: u32, item: &JsValue) -> Array;

    /// The `toLocaleString()` method returns a string representing the elements of the array.

    /// The elements are converted to Strings using their toLocaleString methods and these

    /// Strings are separated by a locale-specific String (such as a comma “,”).

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString)

    #[wasm_bindgen(method, js_name = toLocaleString)]

    pub fn to_locale_string(this: &Array, locales: &JsValue, options: &JsValue) -> JsString;

    /// The `toString()` method returns a string representing the specified array

    /// and its elements.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString)

    #[wasm_bindgen(method, js_name = toString)]

    pub fn to_string(this: &Array) -> JsString;

    /// The `unshift()` method adds one or more elements to the beginning of an

    /// array and returns the new length of the array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift)

    #[wasm_bindgen(method)]

    pub fn unshift(this: &Array, value: &JsValue) -> u32;

}

/// Iterator returned by `Array::into_iter`

#[derive(Debug, Clone)]

pub struct ArrayIntoIter {

    range: std::ops::Range<u32>,

    array: Array,

}

impl std::iter::Iterator for ArrayIntoIter {

    type Item = JsValue;

    #[inline]

    #[inline]

    #[inline]

    #[inline]

}

impl std::iter::DoubleEndedIterator for ArrayIntoIter {

}

impl std::iter::FusedIterator for ArrayIntoIter {}

impl std::iter::ExactSizeIterator for ArrayIntoIter {}

/// Iterator returned by `Array::iter`

#[derive(Debug, Clone)]

pub struct ArrayIter<'a> {

    range: std::ops::Range<u32>,

    array: &'a Array,

}

impl<'a> std::iter::Iterator for ArrayIter<'a> {

    type Item = JsValue;

    #[inline]

    #[inline]

    #[inline]

    #[inline]

}

impl<'a> std::iter::DoubleEndedIterator for ArrayIter<'a> {

}

impl<'a> std::iter::FusedIterator for ArrayIter<'a> {}

impl<'a> std::iter::ExactSizeIterator for ArrayIter<'a> {}

impl Array {

    /// Returns an iterator over the values of the JS array.

    /// Converts the JS array into a new Vec.

}

impl std::iter::IntoIterator for Array {

    type Item = JsValue;

    type IntoIter = ArrayIntoIter;

}

// TODO pre-initialize the Array with the correct length using TrustedLen

impl<A> std::iter::FromIterator<A> for Array

where

    A: AsRef<JsValue>,

{

}

impl<A> std::iter::Extend<A> for Array

where

    A: AsRef<JsValue>,

{

}

impl Default for Array {

}

// ArrayBuffer

extern "C" {

    #[wasm_bindgen(extends = Object, typescript_type = "ArrayBuffer")]

    #[derive(Clone, Debug, PartialEq, Eq)]

    pub type ArrayBuffer;

    /// The `ArrayBuffer` object is used to represent a generic,

    /// fixed-length raw binary data buffer. You cannot directly

    /// manipulate the contents of an `ArrayBuffer`; instead, you

    /// create one of the typed array objects or a `DataView` object

    /// which represents the buffer in a specific format, and use that

    /// to read and write the contents of the buffer.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)

    #[wasm_bindgen(constructor)]

    pub fn new(length: u32) -> ArrayBuffer;

    /// The byteLength property of an object which is an instance of type ArrayBuffer

    /// it's an accessor property whose set accessor function is undefined,

    /// meaning that you can only read this property.

    /// The value is established when the array is constructed and cannot be changed.

    /// This property returns 0 if this ArrayBuffer has been detached.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/byteLength)

    #[wasm_bindgen(method, getter, js_name = byteLength)]

    pub fn byte_length(this: &ArrayBuffer) -> u32;

    /// The `isView()` method returns true if arg is one of the `ArrayBuffer`

    /// views, such as typed array objects or a DataView; false otherwise.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView)

    #[wasm_bindgen(static_method_of = ArrayBuffer, js_name = isView)]

    pub fn is_view(value: &JsValue) -> bool;

    /// The `slice()` method returns a new `ArrayBuffer` whose contents

    /// are a copy of this `ArrayBuffer`'s bytes from begin, inclusive,

    /// up to end, exclusive.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice)

    #[wasm_bindgen(method)]

    pub fn slice(this: &ArrayBuffer, begin: u32) -> ArrayBuffer;

    /// Like `slice()` but with the `end` argument.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice)

    #[wasm_bindgen(method, js_name = slice)]

    pub fn slice_with_end(this: &ArrayBuffer, begin: u32, end: u32) -> ArrayBuffer;

}

// SharedArrayBuffer

extern "C" {

    #[wasm_bindgen(extends = Object, typescript_type = "SharedArrayBuffer")]

    #[derive(Clone, Debug)]

    pub type SharedArrayBuffer;

    /// The `SharedArrayBuffer` object is used to represent a generic,

    /// fixed-length raw binary data buffer, similar to the `ArrayBuffer`

    /// object, but in a way that they can be used to create views

    /// on shared memory. Unlike an `ArrayBuffer`, a `SharedArrayBuffer`

    /// cannot become detached.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer)

    #[wasm_bindgen(constructor)]

    pub fn new(length: u32) -> SharedArrayBuffer;

    /// The byteLength accessor property represents the length of

    /// an `SharedArrayBuffer` in bytes. This is established when

    /// the `SharedArrayBuffer` is constructed and cannot be changed.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/byteLength)

    #[wasm_bindgen(method, getter, js_name = byteLength)]

    pub fn byte_length(this: &SharedArrayBuffer) -> u32;

    /// The `slice()` method returns a new `SharedArrayBuffer` whose contents

    /// are a copy of this `SharedArrayBuffer`'s bytes from begin, inclusive,

    /// up to end, exclusive.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/slice)

    #[wasm_bindgen(method)]

    pub fn slice(this: &SharedArrayBuffer, begin: u32) -> SharedArrayBuffer;

    /// Like `slice()` but with the `end` argument.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/slice)

    #[wasm_bindgen(method, js_name = slice)]

    pub fn slice_with_end(this: &SharedArrayBuffer, begin: u32, end: u32) -> SharedArrayBuffer;

}

// Array Iterator

#[wasm_bindgen]

extern "C" {

    /// The `keys()` method returns a new Array Iterator object that contains the

    /// keys for each index in the array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/keys)

    #[wasm_bindgen(method)]

    pub fn keys(this: &Array) -> Iterator;

    /// The `entries()` method returns a new Array Iterator object that contains

    /// the key/value pairs for each index in the array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries)

    #[wasm_bindgen(method)]

    pub fn entries(this: &Array) -> Iterator;

    /// The `values()` method returns a new Array Iterator object that

    /// contains the values for each index in the array.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values)

    #[wasm_bindgen(method)]

    pub fn values(this: &Array) -> Iterator;

}

/// The `Atomics` object provides atomic operations as static methods.

/// They are used with `SharedArrayBuffer` objects.

///

/// The Atomic operations are installed on an `Atomics` module. Unlike

/// the other global objects, `Atomics` is not a constructor. You cannot

/// use it with a new operator or invoke the `Atomics` object as a

/// function. All properties and methods of `Atomics` are static

/// (as is the case with the Math object, for example).

/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics)

#[allow(non_snake_case)]

pub mod Atomics {

    use super::*;

    #[wasm_bindgen]

    extern "C" {

        /// The static `Atomics.add()` method adds a given value at a given

        /// position in the array and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// You should use `add_bigint` to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/add)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn add(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;

        /// The static `Atomics.add()` method adds a given value at a given

        /// position in the array and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// This method is used to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/add)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = add)]

        pub fn add_bigint(typed_array: &JsValue, index: u32, value: i64) -> Result<i64, JsValue>;

        /// The static `Atomics.and()` method computes a bitwise AND with a given

        /// value at a given position in the array, and returns the old value

        /// at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// You should use `and_bigint` to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/and)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn and(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;

        /// The static `Atomics.and()` method computes a bitwise AND with a given

        /// value at a given position in the array, and returns the old value

        /// at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// This method is used to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/and)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = and)]

        pub fn and_bigint(typed_array: &JsValue, index: u32, value: i64) -> Result<i64, JsValue>;

        /// The static `Atomics.compareExchange()` method exchanges a given

        /// replacement value at a given position in the array, if a given expected

        /// value equals the old value. It returns the old value at that position

        /// whether it was equal to the expected value or not.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// You should use `compare_exchange_bigint` to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = compareExchange)]

        pub fn compare_exchange(

            typed_array: &JsValue,

            index: u32,

            expected_value: i32,

            replacement_value: i32,

        ) -> Result<i32, JsValue>;

        /// The static `Atomics.compareExchange()` method exchanges a given

        /// replacement value at a given position in the array, if a given expected

        /// value equals the old value. It returns the old value at that position

        /// whether it was equal to the expected value or not.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// This method is used to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = compareExchange)]

        pub fn compare_exchange_bigint(

            typed_array: &JsValue,

            index: u32,

            expected_value: i64,

            replacement_value: i64,

        ) -> Result<i64, JsValue>;

        /// The static `Atomics.exchange()` method stores a given value at a given

        /// position in the array and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// You should use `exchange_bigint` to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/exchange)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn exchange(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;

        /// The static `Atomics.exchange()` method stores a given value at a given

        /// position in the array and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// This method is used to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/exchange)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = exchange)]

        pub fn exchange_bigint(

            typed_array: &JsValue,

            index: u32,

            value: i64,

        ) -> Result<i64, JsValue>;

        /// The static `Atomics.isLockFree()` method is used to determine

        /// whether to use locks or atomic operations. It returns true,

        /// if the given size is one of the `BYTES_PER_ELEMENT` property

        /// of integer `TypedArray` types.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree)

        #[wasm_bindgen(js_namespace = Atomics, js_name = isLockFree)]

        pub fn is_lock_free(size: u32) -> bool;

        /// The static `Atomics.load()` method returns a value at a given

        /// position in the array.

        ///

        /// You should use `load_bigint` to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/load)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn load(typed_array: &JsValue, index: u32) -> Result<i32, JsValue>;

        /// The static `Atomics.load()` method returns a value at a given

        /// position in the array.

        ///

        /// This method is used to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/load)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = load)]

        pub fn load_bigint(typed_array: &JsValue, index: i64) -> Result<i64, JsValue>;

        /// The static `Atomics.notify()` method notifies up some agents that

        /// are sleeping in the wait queue.

        /// Note: This operation works with a shared `Int32Array` only.

        /// If `count` is not provided, notifies all the agents in the queue.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/notify)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn notify(typed_array: &Int32Array, index: u32) -> Result<u32, JsValue>;

        /// Notifies up to `count` agents in the wait queue.

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = notify)]

        pub fn notify_with_count(

            typed_array: &Int32Array,

            index: u32,

            count: u32,

        ) -> Result<u32, JsValue>;

        /// The static `Atomics.or()` method computes a bitwise OR with a given value

        /// at a given position in the array, and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// You should use `or_bigint` to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/or)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn or(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;

        /// The static `Atomics.or()` method computes a bitwise OR with a given value

        /// at a given position in the array, and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// This method is used to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/or)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = or)]

        pub fn or_bigint(typed_array: &JsValue, index: u32, value: i64) -> Result<i64, JsValue>;

        /// The static `Atomics.store()` method stores a given value at the given

        /// position in the array and returns that value.

        ///

        /// You should use `store_bigint` to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/store)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn store(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;

        /// The static `Atomics.store()` method stores a given value at the given

        /// position in the array and returns that value.

        ///

        /// This method is used to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/store)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = store)]

        pub fn store_bigint(typed_array: &JsValue, index: u32, value: i64) -> Result<i64, JsValue>;

        /// The static `Atomics.sub()` method subtracts a given value at a

        /// given position in the array and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// You should use `sub_bigint` to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/sub)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn sub(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;

        /// The static `Atomics.sub()` method subtracts a given value at a

        /// given position in the array and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// This method is used to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/sub)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = sub)]

        pub fn sub_bigint(typed_array: &JsValue, index: u32, value: i64) -> Result<i64, JsValue>;

        /// The static `Atomics.wait()` method verifies that a given

        /// position in an `Int32Array` still contains a given value

        /// and if so sleeps, awaiting a wakeup or a timeout.

        /// It returns a string which is either "ok", "not-equal", or "timed-out".

        /// Note: This operation only works with a shared `Int32Array`

        /// and may not be allowed on the main thread.

        ///

        /// You should use `wait_bigint` to operate on a `BigInt64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn wait(typed_array: &Int32Array, index: u32, value: i32) -> Result<JsString, JsValue>;

        /// The static `Atomics.wait()` method verifies that a given

        /// position in an `BigInt64Array` still contains a given value

        /// and if so sleeps, awaiting a wakeup or a timeout.

        /// It returns a string which is either "ok", "not-equal", or "timed-out".

        /// Note: This operation only works with a shared `BigInt64Array`

        /// and may not be allowed on the main thread.

        ///

        /// You should use `wait` to operate on a `Int32Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = wait)]

        pub fn wait_bigint(

            typed_array: &BigInt64Array,

            index: u32,

            value: i64,

        ) -> Result<JsString, JsValue>;

        /// Like `wait()`, but with timeout

        ///

        /// You should use `wait_with_timeout_bigint` to operate on a `BigInt64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = wait)]

        pub fn wait_with_timeout(

            typed_array: &Int32Array,

            index: u32,

            value: i32,

            timeout: f64,

        ) -> Result<JsString, JsValue>;

        /// Like `wait()`, but with timeout

        ///

        /// You should use `wait_with_timeout` to operate on a `Int32Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = wait)]

        pub fn wait_with_timeout_bigint(

            typed_array: &BigInt64Array,

            index: u32,

            value: i64,

            timeout: f64,

        ) -> Result<JsString, JsValue>;

        /// The static `Atomics.waitAsync()` method verifies that a given position in an

        /// `Int32Array` still contains a given value and if so sleeps, awaiting a

        /// wakeup or a timeout. It returns an object with two properties. The first

        /// property `async` is a boolean which if true indicates that the second

        /// property `value` is a promise. If `async` is false then value is a string

        /// whether equal to either "not-equal" or "timed-out".

        /// Note: This operation only works with a shared `Int32Array` and may be used

        /// on the main thread.

        ///

        /// You should use `wait_async_bigint` to operate on a `BigInt64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/waitAsync)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = waitAsync)]

        pub fn wait_async(

            typed_array: &Int32Array,

            index: u32,

            value: i32,

        ) -> Result<Object, JsValue>;

        /// The static `Atomics.waitAsync()` method verifies that a given position in an

        /// `Int32Array` still contains a given value and if so sleeps, awaiting a

        /// wakeup or a timeout. It returns an object with two properties. The first

        /// property `async` is a boolean which if true indicates that the second

        /// property `value` is a promise. If `async` is false then value is a string

        /// whether equal to either "not-equal" or "timed-out".

        /// Note: This operation only works with a shared `BigInt64Array` and may be used

        /// on the main thread.

        ///

        /// You should use `wait_async` to operate on a `Int32Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/waitAsync)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = waitAsync)]

        pub fn wait_async_bigint(

            typed_array: &BigInt64Array,

            index: u32,

            value: i64,

        ) -> Result<Object, JsValue>;

        /// Like `waitAsync()`, but with timeout

        ///

        /// You should use `wait_async_with_timeout_bigint` to operate on a `BigInt64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/waitAsync)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = waitAsync)]

        pub fn wait_async_with_timeout(

            typed_array: &Int32Array,

            index: u32,

            value: i32,

            timeout: f64,

        ) -> Result<Object, JsValue>;

        /// Like `waitAsync()`, but with timeout

        ///

        /// You should use `wait_async_with_timeout` to operate on a `Int32Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/waitAsync)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = waitAsync)]

        pub fn wait_async_with_timeout_bigint(

            typed_array: &BigInt64Array,

            index: u32,

            value: i64,

            timeout: f64,

        ) -> Result<Object, JsValue>;

        /// The static `Atomics.xor()` method computes a bitwise XOR

        /// with a given value at a given position in the array,

        /// and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// You should use `xor_bigint` to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/xor)

        #[wasm_bindgen(js_namespace = Atomics, catch)]

        pub fn xor(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;

        /// The static `Atomics.xor()` method computes a bitwise XOR

        /// with a given value at a given position in the array,

        /// and returns the old value at that position.

        /// This atomic operation guarantees that no other write happens

        /// until the modified value is written back.

        ///

        /// This method is used to operate on a `BigInt64Array` or a `BigUint64Array`.

        ///

        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/xor)

        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = xor)]

        pub fn xor_bigint(typed_array: &JsValue, index: u32, value: i64) -> Result<i64, JsValue>;

    }

}

// BigInt

extern "C" {

    #[derive(Clone, PartialEq, Eq)]

    pub type BigInt;

    #[wasm_bindgen(catch, js_name = BigInt)]

    fn new_bigint(value: &JsValue) -> Result<BigInt, Error>;

    #[wasm_bindgen(js_name = BigInt)]

    fn new_bigint_unchecked(value: &JsValue) -> BigInt;

    /// Clamps a BigInt value to a signed integer value, and returns that value.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/asIntN)

    #[wasm_bindgen(static_method_of = BigInt, js_name = asIntN)]

    pub fn as_int_n(bits: f64, bigint: &BigInt) -> BigInt;

    /// Clamps a BigInt value to an unsigned integer value, and returns that value.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/asUintN)

    #[wasm_bindgen(static_method_of = BigInt, js_name = asUintN)]

    pub fn as_uint_n(bits: f64, bigint: &BigInt) -> BigInt;

    /// Returns a string with a language-sensitive representation of this BigInt value. Overrides the [`Object.prototype.toLocaleString()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString) method.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString)

    #[wasm_bindgen(method, js_name = toLocaleString)]

    pub fn to_locale_string(this: &BigInt, locales: &JsValue, options: &JsValue) -> JsString;

    /// Returns a string representing this BigInt value in the specified radix (base). Overrides the [`Object.prototype.toString()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString) method.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toString)

    #[wasm_bindgen(catch, method, js_name = toString)]

    pub fn to_string(this: &BigInt, radix: u8) -> Result<JsString, RangeError>;

    #[wasm_bindgen(method, js_name = toString)]

    fn to_string_unchecked(this: &BigInt, radix: u8) -> String;

    /// Returns this BigInt value. Overrides the [`Object.prototype.valueOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf) method.

    ///

    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/valueOf)